/**
 * 版本管理模块
 * 负责版本号的获取、比较、存储
 */

class VersionManager {
  /**
   * 获取当前版本号（同步方法）
   * 优先从本地存储读取（更新后的版本），如果本地存储没有，则返回默认值
   * 注意：此方法不会主动从系统获取版本，需要先调用 init() 或 ensureVersionInitialized() 初始化
   */
  getCurrentVersion() {
    try {
      // 优先从本地存储读取（更新后的版本）
      const savedVersion = uni.getStorageSync('app_version')
      if (savedVersion) {
        console.log('[VersionManager] 从本地存储读取版本:', savedVersion)
        return savedVersion
      }
      
      // 如果本地存储没有，返回默认版本
      console.log('[VersionManager] 本地存储无版本信息，返回默认版本: 1.0.0')
      return '1.0.0'
    } catch (error) {
      console.error('[VersionManager] 获取版本号失败:', error)
      return '1.0.0'
    }
  }

  /**
   * 确保版本已初始化（异步方法）
   * 如果本地存储没有版本，则从系统获取并保存
   * @returns {Promise<string>} 当前版本号
   */
  async ensureVersionInitialized() {
    try {
      // 先检查本地存储
      const savedVersion = uni.getStorageSync('app_version')
      if (savedVersion) {
        console.log('[VersionManager] 版本已初始化:', savedVersion)
        return savedVersion
      }

      // 本地存储没有版本，需要从系统获取
      console.log('[VersionManager] 本地存储无版本信息，开始从系统获取...')

      // #ifdef H5
      // H5环境：从update-info.json读取版本
      try {
        const response = await fetch('/update-info.json')
        if (response.ok) {
          const updateInfo = await response.json()
          const version = updateInfo.version || '1.0.0'
          uni.setStorageSync('app_version', version)
          console.log('[VersionManager] 从update-info.json读取版本:', version)
          return version
        }
      } catch (error) {
        console.log('[VersionManager] 无法从update-info.json读取版本:', error)
      }
      // #endif

      // #ifdef APP-PLUS
      // APP环境：从plus.runtime.getProperty读取版本
      if (typeof plus !== 'undefined' && plus.runtime) {
        return new Promise((resolve) => {
          plus.runtime.getProperty(plus.runtime.appid, (widgetInfo) => {
            console.log('[VersionManager] 应用信息:', widgetInfo)
            const manifestVersion = widgetInfo.version
            console.log('[VersionManager] 从plus.runtime.getProperty获取的版本:', manifestVersion)

            if (manifestVersion) {
              uni.setStorageSync('app_version', manifestVersion)
              console.log('[VersionManager] 版本已保存到本地存储:', manifestVersion)
              resolve(manifestVersion)
            } else {
              // 如果getProperty失败，使用默认版本
              const defaultVersion = '1.3.1'
              uni.setStorageSync('app_version', defaultVersion)
              console.log('[VersionManager] 使用默认版本:', defaultVersion)
              resolve(defaultVersion)
            }
          }, (error) => {
            console.error('[VersionManager] 获取应用信息失败:', error)
            // 如果getProperty失败，使用默认版本
            const defaultVersion = '1.3.1'
            uni.setStorageSync('app_version', defaultVersion)
            console.log('[VersionManager] getProperty失败，使用默认版本:', defaultVersion)
            resolve(defaultVersion)
          })
        })
      }
      // #endif

      // 默认版本
      const defaultVersion = '1.0.0'
      uni.setStorageSync('app_version', defaultVersion)
      console.log('[VersionManager] 使用默认版本:', defaultVersion)
      return defaultVersion

    } catch (error) {
      console.error('[VersionManager] 初始化版本失败:', error)
      const defaultVersion = '1.0.0'
      uni.setStorageSync('app_version', defaultVersion)
      return defaultVersion
    }
  }

  /**
   * 比较版本号
   * @param {string} currentVersion 当前版本
   * @param {string} latestVersion 最新版本
   * @returns {number} -1: 需要更新, 0: 版本相同, 1: 当前版本更新
   */
  compareVersions(currentVersion, latestVersion) {
    try {
      const current = currentVersion.split('.').map(Number)
      const latest = latestVersion.split('.').map(Number)
      
      // 补齐版本号长度
      const maxLength = Math.max(current.length, latest.length)
      while (current.length < maxLength) current.push(0)
      while (latest.length < maxLength) latest.push(0)
      
      for (let i = 0; i < maxLength; i++) {
        if (current[i] < latest[i]) return -1
        if (current[i] > latest[i]) return 1
      }
      
      return 0
    } catch (error) {
      console.error('版本比较失败:', error)
      return -1 // 出错时默认需要更新
    }
  }

  /**
   * 获取本地版本信息
   */
  getLocalUpdateInfo() {
    try {
      const info = uni.getStorageSync('update_info')
      if (info) {
        return JSON.parse(info)
      }
    } catch (error) {
      console.error('获取本地版本信息失败:', error)
    }
    return { version: this.getCurrentVersion(), lastCheck: null }
  }

  /**
   * 更新版本信息
   */
  async updateVersionInfo(version, updateInfo) {
    try {
      const newInfo = {
        version: version,
        lastCheck: new Date().toISOString(),
        lastUpdate: new Date().toISOString(),
        updateMessage: updateInfo.updateMessage || updateInfo.message,
        updateMethod: 'wgt'
      }
      
      // 更新本地版本信息
      uni.setStorageSync('update_info', JSON.stringify(newInfo))
      
      // 更新应用版本显示
      uni.setStorageSync('app_version', version)
      
      console.log(`版本信息已更新到: ${version}`)
      console.log('更新详情:', newInfo)
    } catch (error) {
      console.error('更新版本信息失败:', error)
      throw error
    }
  }

  /**
   * 备份当前版本信息
   */
  async backupVersion() {
    try {
      const timestamp = new Date().getTime()
      const backupKey = `backup_${timestamp}`
      
      const currentInfo = this.getLocalUpdateInfo()
      const backupData = {
        timestamp: timestamp,
        version: currentInfo.version,
        backupTime: new Date().toISOString()
      }
      
      uni.setStorageSync(backupKey, backupData)
      
      const backupKeys = uni.getStorageSync('backup_keys') || []
      backupKeys.push(backupKey)
      uni.setStorageSync('backup_keys', backupKeys)
      
      console.log('版本备份完成')
    } catch (error) {
      console.error('备份版本失败:', error)
      throw error
    }
  }

  /**
   * 回滚到上一个版本
   */
  async rollbackVersion() {
    try {
      console.log('开始回滚版本...')
      
      const backupKeys = uni.getStorageSync('backup_keys') || []
      if (backupKeys.length > 0) {
        const latestBackupKey = backupKeys[backupKeys.length - 1]
        const backupData = uni.getStorageSync(latestBackupKey)
        
        if (backupData) {
          uni.setStorageSync('update_info', JSON.stringify({
            version: backupData.version,
            lastCheck: backupData.backupTime
          }))
          
          console.log('版本已回滚')
        }
      }
    } catch (error) {
      console.error('回滚版本失败:', error)
    }
  }
}

export default new VersionManager() 